\chapter{Phases d'analyse}
\section{Analyse lexicale}
Nos tokens sont définis dans le fichier \textbf{while.l} qui contient leurs définitions. Il faut noter que nous utilisons la macro ``define TOKEN(t) (yylval.token = t)'' , ainsi, chacun de nos token est déclaré de la manière suivante :

Déclaration des lexèmes	:
\vspace{2mm}
\newline
\begin{tabular}{|l|r|}
  \hline
  Nom du lexème & Lexème\\
  \hline
  opSuperieurEgal & $>=$ \\
   \hline
\end{tabular}
		
\vspace{3mm}	

Association des lexèmes en token correspondants :
\vspace{2mm}
\newline
\begin{tabular}{|l|r|}
  \hline
  Nom du lexème & Lexeme\\
  \hline
  {opSuperieurEgal} & return TOKEN(SUPEGAL);\\
   \hline
\end{tabular}

\section{Analyse syntaxique}
\paragraph{}
Nous avons définit notre grammaire dans le fichier \textbf{while.y}, avec les règles de celle ci. Voici quelques exemples de règles que nous utilisons :

\begin{bfseries}
Un programme est composé d'une liste de déclarations suivie de statement :
\end{bfseries}
\vspace{2mm}

\begin{lstlisting}[language={}]
<programme> : listeprogrammedeclaration statement
\end{lstlisting}


\vspace{5mm}

\begin{bfseries}
Une liste de déclaration est vide ou contient	des déclarations :
\end{bfseries}
\vspace{2mm}

\begin{lstlisting}[language={}]
<listeprogrammedeclaration> : ''
	|	programmedeclarations
\end{lstlisting}


\vspace{5mm}

\begin{bfseries}
Une déclaration peut être soit une déclaration de fonction soit une déclaration de procédure :
\end{bfseries}
\vspace{2mm}

\begin{lstlisting}[language={}]
<programmedeclaration> ::=
		MOTFONCTION nomfonction PARENTHESEOUVRANTE 
		listeargumentsdeclaration PARENTHESEFERMANTE
		DEUXPOINTS typeT 
		IS statement
	| 	MOTPROCEDURE nomfonction PARENTHESEOUVRANTE
		listeargumentsdeclaration PARENTHESEFERMANTE 
		IS statement
\end{lstlisting}
  
Nous avons géré une ambiguïté qui était mise en évidence lorsque nous reconnaissions le return a la fin d'une fonction. Nous l'avons levée en ajoutant un point virgule a la fin de chacune de nos instructions.

\section{Analyse sémantique}
Par la suite, nous reprenons la grammaire, en instanciant des nœuds pour contenir les différents termes des règles de production :

programme :
listeprogrammedeclaration statement
{
  leprogramme = new NProgrammePrincipal(*\$1,*\$2);
};
Chaque terme principal des règles de production est désigné par \$\$ et les termes qui la composent sont nommés \$1 \$2 \$3 …

Les différentes classes instanciées permettent la représentation du code sous forme d'arbre :
\vspace{2mm}
\newline
\begin{tabular}{|p{4cm}|p{10cm}|}
  \hline
  Nom de classe & Utilisation \\ \hline
  NExpression & Une expression peut etre soir arithmétique (NArithmetique) soit booleenne (NBoolean) \\ \hline
  NStatement & Un statement peut etre une instruction (NStatementInstruction) un if (NIf), un while (NWhile), une procédure (NProcedure) \\ \hline
  NDeclaration &  Une déclaration possède un type et une liste de varaibles NDeclaration(std::string type,variableListe\& variables) \\ \hline
  NArithmetique & Une expression arithmétique est soit un entier (NN) soit un flotant (ND) soit une string (NX) soit une variable (NVariable) \\ \hline
  NVariable & Une variable peut se construire avec un nom et possède un numero entry qui sera renseigné par la suite NVariable(std::string nom) \\ \hline
  NArgument & Un argument est un couple constitué d'une variable et de son type :  NArgument(NArithmetique\& variable, std::string type)  \\ \hline
  NProgramme & Un programme peut etre une procédure, une fonction ou bien le programme principal lui même \\ \hline
  NStatementInstruction & Un statement d'instruction peut se construire avec une instruction : NStatementInstruction(NInstruction\& instruction) \\ \hline
  NInstruction & Une instruction peut être un retour de fonction (NReturn) et retour d'une valeur (NReturnValeur) ou bien une affectation (NAffectation), ou une allocation de tableau (NNew) , ou une désallocation (NFree) et enfin un appel de fonction (NAppelFonction) \\ \hline
\end{tabular}

\begin{minipage}{\textwidth}
\begin{lstlisting}
 class NIf : public NStatement {
	public:
	    NBoolean& booleen;
	    NStatement& statement1;
	    NStatement& statement2;
	    NIf(NBoolean& booleen, 
	    	NStatement& statement1, 
	    	NStatement& statement2) : 
	    	NStatement(),
	    	booleen(booleen), 
	    	statement1(statement1), 
	    	statement2(statement2) {}
  };
\end{lstlisting}
\end{minipage}